home *** CD-ROM | disk | FTP | other *** search
/ CD Actual 22 / PC Actual CD 22.iso / SHARE / wnt / lemmy30.exe / CPPSCAN.C < prev    next >
Encoding:
C/C++ Source or Header  |  1997-08-24  |  21.9 KB  |  922 lines
  1.  
  2. //////////////////////////////////////////////////////////////////////////
  3. //
  4. //  cppscan.c
  5. //
  6. //  Copyright 1997 by James Iuliano
  7. //
  8. //  Permission granted to use this program for development
  9. //  of Lemmy VI editor syntax highlight plug-ins.  Permission
  10. //  for any other use must be obtained by James Iuliano.
  11. //
  12. //////////////////////////////////////////////////////////////////////////
  13.  
  14. #include <windows.h>
  15. #include <stdio.h>
  16. #include <string.h>
  17. #include <ctype.h>
  18.  
  19. #include "syntax.h"
  20. #include "cppscan.h"
  21. #include "dlgmacro.h"
  22.  
  23.  
  24. #define C_KEYWORD   0x01
  25. #define CPP_KEYWORD 0x02
  26.  
  27. typedef struct cpp_extra_struct
  28. {
  29.    short keywords;
  30.    BOOL  cpp_comments;
  31. }
  32. cpp_extra_struct;
  33.  
  34. static parse_context_type  *lpPC;
  35. static cpp_extra_struct    *cpp;
  36.  
  37. //
  38. //  Private routines (forward referenced)...
  39. //
  40. //     The scan_... routines will typically set the lpPC->ParseState member
  41. //     based on what they find...
  42. //
  43. static int isodigit(char digit);
  44. static BOOL test_continuation(char *next_token);
  45. static BOOL scan_comment_conditions(char *text);
  46. static char *scan_from_preprocessor(char *next_token, parse_context_type  *lpPC);
  47. static char *scan_comment(char *next_token, parse_context_type *lpPC);
  48. static char *scan_string(char *next_token, parse_context_type *lpPC);
  49. static int is_c_keyword(char *token);
  50.  
  51.  
  52.  
  53. ////////////////////////////////////////////////////////////////////////
  54. //
  55. //  API Definitions...
  56. //
  57. ////////////////////////////////////////////////////////////////////////
  58.  
  59. DllExport(char *) ParseEngineName()
  60. {
  61.    static char name[32];
  62.  
  63.    strcpy( name, "C/C++ Parser" );
  64.    return(name);
  65. }
  66.  
  67.  
  68.  
  69. //
  70. // ..stubs..
  71. //
  72. DllExport(short) ParsePropertiesAvailable()
  73. { 
  74.    return(TRUE); 
  75. }
  76.  
  77.  
  78.  
  79. long FAR PASCAL PropertiesDialogProc(HWND hWnd, WORD iMessage, WORD wParam, DWORD lParam)
  80. {
  81.     switch (iMessage)
  82.     {
  83.         case WM_INITDIALOG:
  84.          SETCK(IDC_DO_CPP,          (cpp->keywords & CPP_KEYWORD));
  85.          SETCK(IDC_DO_CPP_COMMENTS,  cpp->cpp_comments);
  86.          return TRUE;
  87.         break;
  88.         case WM_COMMAND:
  89.               switch (LOWORD(wParam))
  90.             {
  91.             case IDOK:
  92.                if ( GETCK(IDC_DO_CPP) )
  93.                   cpp->keywords = C_KEYWORD | CPP_KEYWORD;
  94.                else
  95.                   cpp->keywords = C_KEYWORD;
  96.  
  97.                cpp->cpp_comments = GETCK(IDC_DO_CPP_COMMENTS);
  98.  
  99.                SaveEngineInfoInt("CPPDoCPPKeywords", (cpp->keywords & CPP_KEYWORD));
  100.                SaveEngineInfoInt("CPPDoCPPComments", cpp->cpp_comments);
  101.  
  102.                EndDialog(hWnd, 0);
  103.                return(TRUE);
  104.             break;
  105.             case IDCANCEL:
  106.                  EndDialog(hWnd, 0);
  107.                  return(TRUE);
  108.             break;
  109.          }
  110.         break;
  111.     }
  112.     return(0L);
  113. }
  114.  
  115.  
  116.  
  117.  
  118.  
  119.  
  120. static void show_system_error()
  121. {
  122.    LPTSTR         lpMsg;
  123.    DWORD          last_error;
  124.  
  125.    last_error = GetLastError();
  126.    FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
  127.          NULL, last_error, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), 
  128.          (LPTSTR) &lpMsg, 0, NULL);
  129.    MessageBox(GetActiveWindow(), lpMsg, "LoadResource", MB_ICONEXCLAMATION);
  130.    LocalFree(lpMsg);
  131. }
  132.  
  133.  
  134.  
  135.  
  136.  
  137. DllExport(short) ParseProperties( parse_context_type *lpPCLocal )
  138. {
  139.     DLGPROC        lpfnDialogProc;
  140.     int            dlg_return;
  141.     static HANDLE  hDialog;
  142.    HINSTANCE      hInst;
  143.    HINSTANCE      hLib;
  144.    HGLOBAL        prop_hGlbl;
  145.    HWND           hWnd;
  146.    HRSRC          dialog_resource;
  147.  
  148.    lpPC  = lpPCLocal;
  149.    cpp   = (cpp_extra_struct *)lpPC->lpExtra;
  150.    hWnd  = GetActiveWindow();
  151.    hInst = (HINSTANCE)GetWindowLong(hWnd, GWL_HINSTANCE);
  152.    hLib  = lpPC->hLibrary;
  153.  
  154.     lpfnDialogProc = (DLGPROC)MakeProcInstance((FARPROC)PropertiesDialogProc, hInst);
  155.     if ( lpfnDialogProc == NULL )
  156.     {
  157.       cpp  = NULL;
  158.       lpPC = NULL;
  159.     
  160.       return(FALSE);
  161.     }
  162.  
  163.    dialog_resource = FindResource(hLib, "PROPERTIES", RT_DIALOG);
  164.    if ( dialog_resource != NULL )
  165.    {
  166.       prop_hGlbl = LoadResource(hLib, dialog_resource);
  167.       if ( prop_hGlbl != NULL )
  168.       {
  169.           dlg_return  = DialogBoxIndirect( hInst, (LPDLGTEMPLATE)prop_hGlbl, 
  170.                                           hWnd, lpfnDialogProc );
  171.       }
  172.       else
  173.       {
  174.          show_system_error();
  175.          dlg_return = -1;
  176.       }
  177.    }
  178.    else
  179.    {
  180.       show_system_error();
  181.       dlg_return = -1;
  182.    }
  183.  
  184.     if ( dlg_return < 0 )
  185.     {
  186.         MessageBox( hWnd, "Failed to open property dialog.", "C/C++ Properties", MB_OK );
  187.     }
  188.  
  189.     FreeProcInstance((FARPROC)lpfnDialogProc);
  190.    cpp  = NULL;
  191.    lpPC = NULL;
  192.  
  193.    return(TRUE);
  194. }
  195.  
  196.  
  197.  
  198. DllExport(short) ParseCustomKeywordsSupported()                    { return(0); }
  199.  
  200.  
  201.  
  202.  
  203.  
  204.  
  205. DllExport(short) ParseLoadCustomTokens( parse_context_type *lpPC )
  206. {
  207.    //LoadTokenInfo( &(lpPC->CustomToken[0]) );
  208.    return(0);
  209. }
  210.  
  211.  
  212.  
  213.  
  214.  
  215.  
  216. DllExport(short) ParseSaveCustomTokens( parse_context_type *lpPC ) 
  217. { 
  218.    //SaveTokenInfo( &(lpPC->CustomToken[0]) );
  219.    return(0); 
  220. }
  221.  
  222.  
  223.  
  224.  
  225. DllExport(short) ParseConstructor( parse_context_type *lpPC )
  226. {
  227.    lpPC->lpExtra = (void *)malloc(sizeof(cpp_extra_struct));
  228.    cpp = (cpp_extra_struct *)lpPC->lpExtra;
  229.  
  230.    cpp->cpp_comments = (BOOL)LoadEngineInfoInt("CPPDoCPPComments", TRUE);
  231.  
  232.    cpp->keywords     = C_KEYWORD;
  233.    if ( (BOOL)LoadEngineInfoInt("CPPDoCPPKeywords", TRUE) )
  234.       cpp->keywords |= CPP_KEYWORD;
  235.    
  236.    lpPC->CustomTokenMax         = 0;
  237.  
  238.    cpp = NULL;
  239.  
  240.    return(0);
  241. }
  242.  
  243.  
  244.  
  245.  
  246. DllExport(short) ParseDestructor( parse_context_type *lpPC )
  247. {
  248.    free( lpPC->lpExtra );
  249.    lpPC->lpExtra = NULL;
  250.  
  251.    return(0);
  252. }
  253.  
  254.  
  255.  
  256. DllExport(short) ParseInitRedraw( parse_context_type *lpPC )
  257. {
  258.    return(0);
  259. }
  260.  
  261.  
  262.  
  263. DllExport(short) ParseInitParser( parse_context_type *lpPC )
  264. {
  265.    return(0);
  266. }
  267.  
  268.  
  269.  
  270.  
  271. DllExport(short) ParseBackscan( parse_context_type *lpPC )
  272. {
  273.    char *text;
  274.  
  275.    text = lpPC->lpParseText;
  276.  
  277.    if ( (strlen( text ) >= 2) &&
  278.         ( text[strlen(text)-1] == '\\') )
  279.    {
  280.       return(0);
  281.    }
  282.  
  283.    if ( !scan_comment_conditions(text) )
  284.    {
  285.       return(0);
  286.    }
  287.  
  288.    lpPC->FinishBackscan = TRUE;
  289.    return(0);
  290. }
  291.  
  292.  
  293.  
  294.  
  295.  
  296. DllExport(short) ParseToken( parse_context_type *lpPC )
  297. {
  298.    char  *next_token;
  299.    char  *tmp_pointer;
  300.    char      akeyword[15];        // 
  301.    int    flag_period = FALSE;     // Flag for decimal point on decimal numbers
  302.    int    flag_exp    = FALSE;    // Flag for exponent (E|e) on decimal numbers
  303.  
  304.    cpp = (cpp_extra_struct *)lpPC->lpExtra;
  305.  
  306.    next_token = SkipWhiteSpace( lpPC->lpParseText );
  307.  
  308.    if ( (lpPC->ParseState != st_fresh_start) &&
  309.         (lpPC->PreviousLine < lpPC->ScanningLine) )
  310.    {
  311.       switch ( lpPC->ScannedToken )
  312.       {
  313.          case tk_string:
  314.             next_token = scan_string(next_token, lpPC);
  315.  
  316.             lpPC->lpParseText = SkipWhiteSpace( next_token );
  317.  
  318.             return(0);
  319.          break;
  320.          case tk_comment:
  321.             next_token = scan_comment(next_token, lpPC);
  322.  
  323.             lpPC->lpParseText = SkipWhiteSpace( next_token );
  324.             
  325.             return(0);
  326.          break;
  327.          case tk_preprocessor:
  328.             next_token = scan_from_preprocessor(next_token, lpPC);
  329.       
  330.             lpPC->lpParseText  = next_token;
  331.             lpPC->ScannedToken = tk_preprocessor;
  332.  
  333.             return(0);
  334.          break;
  335.       }
  336.    }
  337.  
  338.    //
  339.    //  Check for preprocessor first...
  340.    //
  341.    if ( (lpPC->ScanColumn == 0) && (*next_token == '#') ) 
  342.    {
  343.        next_token = scan_from_preprocessor(next_token, lpPC);
  344.  
  345.        lpPC->lpParseText  = next_token;
  346.        lpPC->ScannedToken = tk_preprocessor;
  347.        
  348.        return(0);
  349.    }
  350.  
  351.    //
  352.    //  '.' could be either struct or float - advance over the period if float
  353.    //
  354.    if ( *next_token == '.' && isdigit( *(next_token + 1) ) ) 
  355.    {
  356.       flag_period = TRUE;
  357.       next_token++;
  358.    }
  359.  
  360.    //
  361.    //  '_' is really considered alpha
  362.    //  If punctuation of some type...figure it out
  363.    //
  364.    if ( ispunct( *next_token ) && *next_token != '_'  ) 
  365.    {
  366.         // If next token is of STRING type
  367.         if ( *next_token == '"' ) 
  368.         {
  369.             next_token++;
  370.  
  371.             next_token = scan_string(next_token, lpPC);
  372.  
  373.             lpPC->lpParseText    = SkipWhiteSpace( next_token );
  374.             lpPC->ScannedToken = tk_string;
  375.  
  376.              return(0);
  377.         }
  378.  
  379.         // If next token is a single CHAR STRING type
  380.         else if ( *next_token == '\'' ) 
  381.         {
  382.             next_token++;
  383.  
  384.             while ( (*next_token != '\'') && *next_token ) 
  385.             {
  386.                 if ( *next_token == '\\' )
  387.                     next_token++;
  388.  
  389.                 next_token++;
  390.             }
  391.  
  392.             //(*aline) = remove_white_space( ++next_token );
  393.             if ( *next_token ) ++next_token;
  394.  
  395.             lpPC->lpParseText  = SkipWhiteSpace( next_token );
  396.             lpPC->ParseState   = st_fresh_start;
  397.             lpPC->ScannedToken = tk_char;
  398.  
  399.             return(0);
  400.         }
  401.  
  402.         // If next token is of COMMENT (C++ variety) type
  403.         else if ( *next_token == '/' && *(next_token + 1) == '/' && cpp->cpp_comments ) 
  404.         {
  405.             lpPC->lpParseText = &lpPC->lpParseText[strlen(lpPC->lpParseText)]; // null terminator
  406.             lpPC->ParseState = st_fresh_start;
  407.             lpPC->ScannedToken = tk_comment;
  408.  
  409.             return(0);
  410.         }
  411.  
  412.         // If next token is of COMMENT (C variety) type
  413.         else if ( *next_token == '/' && *(next_token + 1) == '*' ) 
  414.         {
  415.             next_token += 2;
  416.             
  417.             next_token = scan_comment(next_token, lpPC);
  418.  
  419.             lpPC->lpParseText = SkipWhiteSpace(next_token);
  420.             lpPC->ScannedToken = tk_comment;
  421.  
  422.             return(0);
  423.         }
  424.  
  425.         //
  426.         //  Default...
  427.         //
  428.         else 
  429.         {
  430.            ++(lpPC->lpParseText);
  431.            lpPC->ParseState   = st_fresh_start;
  432.            lpPC->ScannedToken = tk_none;
  433.            return(0);
  434.         }
  435.     }
  436.  
  437.     // Number of some type ... decimal, hex, or octal
  438.     else if ( isdigit( *next_token ) ) 
  439.     {
  440.         // Hex
  441.         if ( *next_token == '0' && *(next_token + 1) =='x' && !flag_period ) 
  442.         {
  443.             next_token += 2;
  444.  
  445.             if ( !isxdigit( *next_token )) 
  446.          {
  447.                 lpPC->lpParseText    = SkipWhiteSpace(next_token);
  448.                 lpPC->ScannedToken = tk_none;
  449.                 lpPC->ParseState   = st_fresh_start;
  450.                 return(-1);
  451.             }
  452.  
  453.             while ( isxdigit( *next_token ) && *next_token ) 
  454.             {
  455.                 next_token++;
  456.             }
  457.  
  458.             if ( ((tolower( *next_token ) == 'l') || (tolower( *next_token ) == 'u' )) && 
  459.                   !isalnum( *(next_token + 1) ) 
  460.             ) 
  461.             {
  462.                 next_token += 1;
  463.             }
  464.  
  465.             if ( isalpha( *next_token ) ) 
  466.             {
  467.                lpPC->lpParseText    = SkipWhiteSpace(++next_token);
  468.                lpPC->ScannedToken = tk_none;
  469.                lpPC->ParseState   = st_fresh_start;
  470.                return(-1);
  471.             }
  472.  
  473.             lpPC->lpParseText    = SkipWhiteSpace(next_token);
  474.             lpPC->ParseState   = st_fresh_start;
  475.             lpPC->ScannedToken = tk_number;
  476.         }
  477.  
  478.         // Octal..
  479.         else if ( *next_token == '0' && isdigit( *(next_token + 1) ) && !flag_period ) 
  480.         {
  481.             next_token += 1;
  482.  
  483.             while ( isodigit( *next_token ) && *next_token ) 
  484.             {
  485.                 next_token++;
  486.             }
  487.  
  488.             if ( ((tolower( *next_token ) == 'l') || (tolower( *next_token ) == 'u' )) && 
  489.                   !isalnum( *(next_token + 1) ) 
  490.                ) 
  491.             {
  492.                 next_token += 1;
  493.             }
  494.  
  495.             if ( isalnum( *next_token ) ) 
  496.             {
  497.                 lpPC->lpParseText = SkipWhiteSpace(next_token);
  498.                 lpPC->ParseState = st_fresh_start;
  499.                 lpPC->ScannedToken = tk_none;
  500.                 return(-1);
  501.             }
  502.  
  503.             lpPC->lpParseText = SkipWhiteSpace(next_token);
  504.             lpPC->ParseState = st_fresh_start;
  505.             lpPC->ScannedToken = tk_number;
  506.             return(0);
  507.         }
  508.         else 
  509.         {
  510. Decimal:
  511.             while ( isdigit( *next_token ) && *next_token ) 
  512.             {
  513.                 next_token++;
  514.             }
  515.  
  516.             //
  517.             // decimal point.
  518.             //
  519.             if ( *next_token == '.' ) 
  520.             {
  521.                 next_token++;
  522.  
  523.                 if ( flag_period ) 
  524.             {
  525.                     lpPC->lpParseText = SkipWhiteSpace(next_token);
  526.                     lpPC->ParseState = st_fresh_start;
  527.                     lpPC->ScannedToken = tk_none;
  528.                     return(-1);
  529.                 }
  530.                 else 
  531.             {
  532.                     flag_period = TRUE;
  533.                     goto Decimal;
  534.                 }
  535.              }
  536.  
  537.              //
  538.              //  exponential form...
  539.              //
  540.              if ( tolower( *next_token ) == 'e' ) 
  541.             {
  542.                 next_token++;
  543.  
  544.                 if ( flag_exp ) 
  545.             {
  546.                     lpPC->lpParseText = SkipWhiteSpace(next_token);
  547.                     lpPC->ParseState = st_fresh_start;
  548.                     lpPC->ScannedToken = tk_none;
  549.                     return(-1);
  550.                 }
  551.                 else 
  552.             {
  553.                     flag_exp = TRUE;
  554.  
  555.                     if ( *next_token == '+' || *next_token == '-' ) 
  556.                {
  557.                         next_token++;
  558.                     }
  559.  
  560.                     if ( !isdigit( *next_token ) ) 
  561.                     {
  562.                         lpPC->lpParseText = SkipWhiteSpace(++next_token);
  563.                         lpPC->ParseState = st_fresh_start;
  564.                         lpPC->ScannedToken = tk_none;
  565.                         return(-1);
  566.                     }
  567.  
  568.                     goto Decimal;
  569.                 }
  570.             }
  571.  
  572.             if ( flag_exp || flag_period ) 
  573.             {
  574.                 if ( (( tolower( *next_token ) == 'l' )  || 
  575.                       ( tolower( *next_token ) == 'f' )) && !isalnum( *(next_token + 1) ) 
  576.                    )
  577.                 {
  578.                     next_token += 1;
  579.                 }
  580.             }
  581.             
  582.             else 
  583.             {
  584.                 if ( (( tolower( *next_token ) == 'l' )  || 
  585.                       ( tolower( *next_token ) == 'u' )) && !isalnum( *(next_token + 1) ) 
  586.                    )
  587.                 {
  588.                     next_token += 1;
  589.                 }
  590.             }
  591.  
  592.             if ( isalpha( *next_token ) ) 
  593.             {
  594.                 lpPC->lpParseText  = SkipWhiteSpace(++next_token);
  595.                 lpPC->ParseState = st_fresh_start;
  596.                 lpPC->ScannedToken = tk_none;
  597.                 return(-1);
  598.             }
  599.  
  600.             lpPC->lpParseText = SkipWhiteSpace(next_token);
  601.             lpPC->ParseState = st_fresh_start;
  602.             lpPC->ScannedToken = tk_number;
  603.             return(0);
  604.         }
  605.     }
  606.  
  607.     // Keywords...
  608.     else 
  609.     {
  610.         tmp_pointer = next_token;
  611.  
  612.         //
  613.         //  Suck it in...
  614.         //
  615.         while (( isalnum( *tmp_pointer ) || *tmp_pointer == '_' ) && *tmp_pointer ) {
  616.             tmp_pointer++;
  617.         }
  618.  
  619.         lpPC->lpParseText = SkipWhiteSpace(tmp_pointer);
  620.  
  621.         // So it doesn't crap out for long non-keywords
  622.         if ( (tmp_pointer - next_token) > 10 ) 
  623.         {
  624.            lpPC->ParseState = st_fresh_start;
  625.            lpPC->ScannedToken = tk_none;
  626.            return(0);
  627.         }
  628.  
  629.         strncpy( akeyword, next_token, (tmp_pointer - next_token) );
  630.         akeyword[ tmp_pointer - next_token ] = '\0';
  631.  
  632.         if ( is_c_keyword( akeyword ) ) 
  633.       {
  634.            lpPC->ParseState = st_fresh_start;
  635.            lpPC->ScannedToken = tk_keyword;
  636.            return(0);
  637.         }
  638.  
  639.         lpPC->ParseState   = st_fresh_start;
  640.         lpPC->ScannedToken = tk_none;
  641.         return(0);
  642.     }
  643. }
  644.  
  645.  
  646.  
  647.  
  648.  
  649.  
  650. ////////////////////////////////////////////////////////////////////////
  651. //
  652. //  Internal Routines...
  653. //
  654. ////////////////////////////////////////////////////////////////////////
  655.  
  656. static int isodigit( char digit )
  657. {
  658.     if ( digit >= '0' && digit <= '7' )
  659.         return( TRUE );
  660.  
  661.     return( FALSE );
  662. }
  663.  
  664.  
  665.  
  666.  
  667. static BOOL test_continuation(char *next_token)
  668. {
  669.    return( (*next_token) && (*next_token == '\\') && !*(next_token+1) );
  670. }
  671.  
  672.  
  673.  
  674.  
  675.  
  676. static BOOL scan_comment_conditions(char *text)
  677. {
  678.    char *scan_text, *sptr;
  679.    char *close_comment;
  680.    char *open_comment;
  681.    char *quote;
  682.    //char *pound;
  683.  
  684.    if ( text == NULL ) return(FALSE);
  685.  
  686.    sptr = scan_text = (char *)malloc(strlen(text)+1);
  687.    strcpy(scan_text,text);
  688.  
  689.    close_comment = strstr(scan_text, "*/");
  690.    open_comment  = strstr(scan_text, "/*");
  691.    quote         = strstr(scan_text, "\"");
  692.  
  693.    if ( !quote )
  694.      if ( open_comment || close_comment ) 
  695.      {
  696.         free(sptr);
  697.         return(TRUE);
  698.      }
  699.  
  700.    free(sptr);
  701.  
  702.    return(FALSE);
  703. }
  704.    
  705.  
  706.  
  707.  
  708. static char *scan_from_preprocessor( char                *next_token, 
  709.                                      parse_context_type  *lpPC )
  710. {
  711.    while ( *next_token ) 
  712.    {
  713.       if ( (*next_token == '/') &&
  714.            (*(next_token + 1) == '/') )
  715.          break;
  716.  
  717.       if ( (*next_token == '/') &&
  718.            (*(next_token + 1) == '*') )
  719.          break;
  720.             
  721.       if ( test_continuation(next_token) )
  722.       {
  723.          lpPC->ParseState = st_continue_previous;
  724.          next_token++;
  725.          break;
  726.       }
  727.  
  728.       lpPC->ParseState = st_fresh_start;
  729.       next_token++;
  730.    }
  731.  
  732.    return(next_token);
  733. }
  734.  
  735.  
  736.  
  737.  
  738.  
  739. static char *scan_comment(char *next_token, parse_context_type *lpPC)
  740. {            
  741.    BOOL done;
  742.  
  743.    done = FALSE;
  744.    while ( !done ) 
  745.    {
  746.        while ( (*next_token != '/') && *next_token ) 
  747.       {
  748.           next_token++;
  749.         }
  750.         
  751.       if ( *(next_token - 1) == '*' || !(*next_token) ) 
  752.       {
  753.          if ( !(*next_token) )
  754.             lpPC->ParseState = st_continue_comment;
  755.          else
  756.             lpPC->ParseState = st_fresh_start;
  757.  
  758.            done = TRUE;
  759.         }
  760.  
  761.         if ( *next_token ) next_token++;
  762.     }
  763.  
  764.    return(next_token);
  765. }
  766.  
  767.  
  768.  
  769.  
  770.  
  771. static char *scan_string(char *next_token, parse_context_type *lpPC)
  772. {            
  773.    while ( (*next_token != '"') && *next_token ) 
  774.    {
  775.       if ( test_continuation(next_token) )
  776.       {
  777.          lpPC->ParseState = st_continue_previous;
  778.          ++next_token;
  779.          break;
  780.       }
  781.  
  782.       lpPC->ParseState = st_fresh_start;
  783.       if ( *next_token == '\\' ) next_token++;
  784.       next_token++;
  785.    }
  786.  
  787.    if ( *next_token ) ++next_token;
  788.  
  789.    return(next_token);
  790. }
  791.  
  792.  
  793.  
  794.  
  795. //
  796. //  Keyword stuff...
  797. //
  798. static int is_c_keyword( char *token )
  799. {
  800.    typedef struct keyword_type
  801.    {
  802.       char *kw;
  803.       BOOL  lang;
  804.    }
  805.    keyword_type;
  806.  
  807.     static keyword_type keywords_2[] = 
  808.    {
  809.         "do", C_KEYWORD|CPP_KEYWORD,    /* C   */
  810.         "if", C_KEYWORD|CPP_KEYWORD,   /* C   */
  811.         NULL, NULL 
  812.     };
  813.  
  814.     static keyword_type keywords_3[] = 
  815.    {
  816.        "for", C_KEYWORD|CPP_KEYWORD,   /* C   */
  817.        "int", C_KEYWORD|CPP_KEYWORD,   /* C   */
  818.        "asm", CPP_KEYWORD,  /* C++?*/
  819.        "new", CPP_KEYWORD,   /* C++ */
  820.        "try", CPP_KEYWORD,   /* C++ */
  821.        NULL, NULL
  822.    };
  823.  
  824.     static keyword_type keywords_4[] = {
  825.                                    "auto", C_KEYWORD|CPP_KEYWORD,   /* C   */
  826.                                    "case", C_KEYWORD|CPP_KEYWORD,   /* C   */
  827.                                    "char", C_KEYWORD|CPP_KEYWORD,   /* C   */
  828.                                    "else", C_KEYWORD|CPP_KEYWORD,   /* C   */
  829.                                    "enum", C_KEYWORD|CPP_KEYWORD,   /* C   */
  830.                                    "goto", C_KEYWORD|CPP_KEYWORD,   /* C   */
  831.                                    "long", C_KEYWORD|CPP_KEYWORD,   /* C   */
  832.                                    "void", C_KEYWORD|CPP_KEYWORD,   /* C   */
  833.                                    "bool", CPP_KEYWORD,   /* New as of GCC 2.6.0  */
  834.                                    "this", CPP_KEYWORD,   /* C++ */
  835.                                    NULL, NULL 
  836.                                  };
  837.  
  838.     static keyword_type keywords_5[] = {
  839.                                    "break", C_KEYWORD|CPP_KEYWORD,   /* C   */
  840.                                    "const", C_KEYWORD|CPP_KEYWORD,   /* C   */
  841.                                    "float", C_KEYWORD|CPP_KEYWORD,   /* C   */
  842.                                    "short", C_KEYWORD|CPP_KEYWORD,   /* C   */
  843.                                    "union", C_KEYWORD|CPP_KEYWORD,   /* C   */
  844.                                    "while", C_KEYWORD|CPP_KEYWORD,   /* C   */
  845.                                    "catch", CPP_KEYWORD,   /* C++ */
  846.                                    "class", CPP_KEYWORD,   /* C++ */
  847.                                    "throw", CPP_KEYWORD,   /* C++ */
  848.                                    NULL, NULL 
  849.                                  };
  850.  
  851.     static keyword_type keywords_6[] = {
  852.                                    "double", C_KEYWORD|CPP_KEYWORD,   /* C   */
  853.                                    "extern", C_KEYWORD|CPP_KEYWORD,   /* C   */
  854.                                    "return", C_KEYWORD|CPP_KEYWORD,   /* C   */
  855.                                    "signed", C_KEYWORD|CPP_KEYWORD,   /* C   */
  856.                                    "sizeof", C_KEYWORD|CPP_KEYWORD,   /* C   */
  857.                                    "static", C_KEYWORD|CPP_KEYWORD,   /* C   */
  858.                                    "struct", C_KEYWORD|CPP_KEYWORD,   /* C   */
  859.                                    "switch", C_KEYWORD|CPP_KEYWORD,   /* C   */
  860.                                    "delete", CPP_KEYWORD,   /* C++ */
  861.                                    "friend", CPP_KEYWORD,   /* C++ */
  862.                                    "inline", CPP_KEYWORD,   /* C++ */
  863.                                    "public", CPP_KEYWORD,   /* C++ */
  864.                                    NULL, NULL 
  865.                                  };
  866.  
  867.     static keyword_type keywords_7[] = {
  868.                                    "default", C_KEYWORD|CPP_KEYWORD,   /* C   */
  869.                                    "typedef", C_KEYWORD|CPP_KEYWORD,   /* C   */
  870.                                    "private", CPP_KEYWORD,   /* C++ */
  871.                                    "virtual", CPP_KEYWORD,   /* C++ */
  872.                                    NULL, NULL 
  873.                                  };
  874.  
  875.     static keyword_type keywords_8[] = {
  876.                                    "continue", C_KEYWORD|CPP_KEYWORD,   /* C   */
  877.                                    "register", C_KEYWORD|CPP_KEYWORD,   /* C   */
  878.                                    "unsigned", C_KEYWORD|CPP_KEYWORD,   /* C   */
  879.                                    "volatile", C_KEYWORD|CPP_KEYWORD,   /* C   */
  880.                                    "operator", CPP_KEYWORD,   /* C++ */
  881.                                    "template", CPP_KEYWORD,   /* C++ */
  882.                                    NULL, NULL 
  883.                                  };
  884.  
  885.     static keyword_type keywords_9[] = {
  886.                                    "protected", CPP_KEYWORD,   /* C++ */
  887.                                    NULL, NULL 
  888.                                  };
  889.                               
  890.     int    count = 0;
  891.     keyword_type *    keywords;
  892.  
  893.     switch ( strlen( token ) ) {
  894.         case 2: keywords = keywords_2;
  895.                 break;
  896.         case 3: keywords = keywords_3;
  897.                 break;
  898.         case 4: keywords = keywords_4;
  899.                 break;
  900.         case 5: keywords = keywords_5;
  901.                 break;
  902.         case 6: keywords = keywords_6;
  903.                 break;
  904.         case 7: keywords = keywords_7;
  905.                 break;
  906.         case 8: keywords = keywords_8;
  907.                 break;
  908.         case 9: keywords = keywords_9;
  909.                 break;
  910.         default: return( FALSE );
  911.     }
  912.  
  913.     for ( ; keywords[ count ].kw != NULL; count++ ) {
  914.         if (  strcmp( keywords[ count ].kw, token ) == 0 &&
  915.            (keywords[ count ].lang & cpp->keywords) )
  916.             return( TRUE );
  917.     }
  918.  
  919.     return( FALSE );
  920.  
  921. }
  922.